/**
 * 问句列表页面逻辑
 *
 * @author AI Crawlers Team
 * @date 2025-10-10
 * @version 3.0 - 修复重复声明问题
 */

console.log('=== 问句列表JS加载开始 v3.0 ===');
console.log('questionList是否已存在:', typeof questionList !== 'undefined');

// 清理可能存在的旧实例
if (typeof questionList !== 'undefined') {
    console.log('检测到旧的questionList实例，开始清理...');
    if (questionList.table) {
        try {
            console.log('销毁旧DataTable实例...');
            questionList.table.destroy();
            $('#questionTable').empty();
            console.log('✅ 旧实例清理成功');
        } catch (e) {
            console.error('❌ 清理旧实例失败:', e);
        }
    }
} else {
    console.log('✅ 首次加载，无需清理');
}

console.log('开始声明新的questionList对象...');
var questionList = {
    
    // DataTable实例
    table: null,
    
    // 当前正在配置的问句ID
    currentQuestionId: null,
    
    /**
     * 初始化
     */
    init() {
        this.initTable();
        this.bindEvents();
        this.loadProductList();
        this.loadCategoryList();
    },
    
    /**
     * 初始化表格
     */
    initTable() {
        this.table = $('#questionTable').DataTable({
            processing: true,
            serverSide: true,
            ajax: {
                url: `${API_CONFIG.BASE_URL}/questions`,
                type: 'GET',
                data: function(d) {
                    // 自定义请求参数
                    return {
                        page: Math.floor(d.start / d.length) + 1,
                        size: d.length,
                        keyword: $('#searchKeyword').val(),
                        category: $('#searchCategory').val(),
                        productId: $('#searchProductId').val() || null,
                        productCategoryId: $('#searchProductCategoryId').val() || null,
                        status: $('#searchStatus').val()
                    };
                },
                dataSrc: function(json) {
                    // 处理返回数据
                    json.recordsTotal = json.data.total;
                    json.recordsFiltered = json.data.total;
                    return json.data.list;
                }
            },
            language: {
                // 使用本地中文配置，避免CORS问题
                "sProcessing": "处理中...",
                "sLengthMenu": "显示 _MENU_ 项结果",
                "sZeroRecords": "没有匹配结果",
                "sInfo": "显示第 _START_ 至 _END_ 项结果，共 _TOTAL_ 项",
                "sInfoEmpty": "显示第 0 至 0 项结果，共 0 项",
                "sInfoFiltered": "(由 _MAX_ 项结果过滤)",
                "sInfoPostFix": "",
                "sSearch": "搜索:",
                "sUrl": "",
                "sEmptyTable": "表中数据为空",
                "sLoadingRecords": "载入中...",
                "sInfoThousands": ",",
                "oPaginate": {
                    "sFirst": "首页",
                    "sPrevious": "上页",
                    "sNext": "下页",
                    "sLast": "末页"
                },
                "oAria": {
                    "sSortAscending": ": 以升序排列此列",
                    "sSortDescending": ": 以降序排列此列"
                }
            },
            columns: [
                { 
                    data: 'questionId',
                    className: 'text-center'
                },
                { 
                    data: 'questionContent',
                    render: function(data) {
                        // 内容过长时截断
                        if (data && data.length > 50) {
                            return `<span title="${utils.escapeHtml(data)}">${utils.escapeHtml(data.substring(0, 50))}...</span>`;
                        }
                        return utils.escapeHtml(data);
                    }
                },
                { 
                    data: 'category',
                    className: 'text-center',
                    render: function(data) {
                        return data ? `<span class="badge bg-info">${data}</span>` : '-';
                    }
                },
                { 
                    data: 'productCategory',
                    className: 'text-center',
                    render: function(data) {
                        return data || '-';
                    }
                },
                { 
                    data: 'tags',
                    render: function(data) {
                        if (!data || data.length === 0) return '-';
                        return data.map(tag => `<span class="badge bg-secondary me-1">${tag}</span>`).join('');
                    }
                },
                { 
                    data: 'priority',
                    className: 'text-center',
                    render: function(data) {
                        const priorityClass = utils.getPriorityClass(data);
                        const priorityText = { high: '高', medium: '中', low: '低' }[data] || '-';
                        return `<span class="badge bg-${priorityClass}">${priorityText}</span>`;
                    }
                },
                { 
                    data: 'status',
                    className: 'text-center',
                    render: function(data) {
                        const statusClass = utils.getStatusClass(data);
                        const statusText = utils.getStatusText(data);
                        return `<span class="badge bg-${statusClass}">${statusText}</span>`;
                    }
                },
                { 
                    data: 'collectCount',
                    className: 'text-center',
                    render: function(data) {
                        return data || 0;
                    }
                },
                { 
                    data: 'createTime',
                    className: 'text-center',
                    render: function(data) {
                        return utils.formatDate(data);
                    }
                },
                {
                    data: null,
                    orderable: false,
                    className: 'text-center',
                    render: function(data, type, row) {
                        return `
                            <button class="btn btn-sm btn-primary" onclick="questionList.edit(${row.questionId})" title="编辑">
                                编辑
                            </button>
                            <button class="btn btn-sm btn-info" onclick="questionList.configProducts(${row.questionId})" title="配置关联产品">
                                产品
                            </button>
                            <button class="btn btn-sm btn-warning" onclick="questionList.configCategories(${row.questionId})" title="配置关联类别">
                                类别
                            </button>
                            <button class="btn btn-sm btn-danger" onclick="questionList.delete(${row.questionId})" title="删除">
                                删除
                            </button>
                        `;
                    }
                }
            ],
            pageLength: API_CONFIG.PAGE_SIZE,
            lengthMenu: API_CONFIG.PAGE_SIZE_OPTIONS.map(size => [size, `${size} 条/页`]),
            order: [[0, 'desc']] // 默认按ID降序
        });
    },
    
    /**
     * 绑定事件
     */
    bindEvents() {
        // 搜索框回车事件
        $('#searchKeyword').on('keypress', function(e) {
            if (e.which === 13) {
                questionList.search();
            }
        });
    },
    
    /**
     * 搜索
     */
    search() {
        this.table.ajax.reload();
    },
    
    /**
     * 重置搜索
     */
    reset() {
        $('#searchKeyword').val('');
        $('#searchCategory').val('');
        $('#searchProductId').val('');
        $('#searchProductCategoryId').val('');
        $('#searchStatus').val('');
        this.table.ajax.reload();
    },
    
    /**
     * 加载产品列表（用于筛选下拉框）
     */
    async loadProductList() {
        try {
            const res = await productApi.getList({ page: 1, size: 1000, status: 1 });
            const products = res.data.list || [];
            
            const select = $('#searchProductId, #selectProduct');
            select.each(function() {
                const $this = $(this);
                const placeholder = $this.attr('id') === 'searchProductId' ? '筛选产品' : '请选择产品';
                $this.html(`<option value="">${placeholder}</option>`);
                products.forEach(p => {
                    $this.append(`<option value="${p.productId}">${p.productName}${p.brand ? ' - ' + p.brand : ''}</option>`);
                });
            });
        } catch (error) {
            console.error('加载产品列表失败:', error);
        }
    },
    
    /**
     * 加载产品类别列表（用于筛选下拉框）
     */
    async loadCategoryList() {
        try {
            const res = await categoryApi.getAll();
            const categories = res.data || [];
            
            const select = $('#searchProductCategoryId, #selectCategory');
            select.each(function() {
                const $this = $(this);
                const placeholder = $this.attr('id') === 'searchProductCategoryId' ? '筛选产品类别' : '请选择产品类别';
                $this.html(`<option value="">${placeholder}</option>`);
                categories.forEach(c => {
                    $this.append(`<option value="${c.categoryId}" data-name="${c.categoryName}">${c.categoryName}</option>`);
                });
            });
        } catch (error) {
            console.error('加载产品类别失败:', error);
        }
    },
    
    /**
     * 显示添加对话框
     */
    showAddDialog() {
        $('#questionFormModal .modal-title').text('添加问句');
        $('#questionForm')[0].reset();
        $('#questionId').val('');
        $('#questionStatus').val('1');
        $('#questionPriority').val('medium');
        
        new bootstrap.Modal('#questionFormModal').show();
    },
    
    /**
     * 编辑
     */
    async edit(id) {
        try {
            utils.showLoading('加载中...');
            const res = await questionApi.getById(id);
            utils.hideLoading();
            
            // 填充表单
            $('#questionFormModal .modal-title').text('编辑问句');
            $('#questionId').val(res.data.questionId);
            $('#questionContent').val(res.data.questionContent);
            $('#questionCategory').val(res.data.category || '');
            $('#productCategory').val(res.data.productCategory || '');
            $('#questionPriority').val(res.data.priority || 'medium');
            $('#questionStatus').val(res.data.status);
            $('#questionTags').val(res.data.tags ? res.data.tags.join(',') : '');
            $('#questionRemark').val(res.data.remark || '');
            
            new bootstrap.Modal('#questionFormModal').show();
        } catch (error) {
            utils.hideLoading();
            console.error('加载问句失败：', error);
        }
    },
    
    /**
     * 保存
     */
    async save() {
        const id = $('#questionId').val();
        
        // 获取表单数据
        const data = {
            questionContent: $('#questionContent').val().trim(),
            category: $('#questionCategory').val(),
            productCategory: $('#productCategory').val().trim(),
            priority: $('#questionPriority').val(),
            status: parseInt($('#questionStatus').val()),
            tags: utils.stringToArray($('#questionTags').val()),
            remark: $('#questionRemark').val().trim()
        };
        
        // 表单验证
        if (!data.questionContent) {
            utils.error('请输入问句内容');
            return;
        }
        
        try {
            utils.showLoading('保存中...');
            
            if (id) {
                // 更新
                await questionApi.update(id, data);
            } else {
                // 创建
                await questionApi.create(data);
            }
            
            utils.hideLoading();
            utils.success('保存成功');
            
            // 关闭对话框
            bootstrap.Modal.getInstance('#questionFormModal').hide();
            
            // 刷新表格
            this.table.ajax.reload();
            
        } catch (error) {
            utils.hideLoading();
            console.error('保存问句失败：', error);
        }
    },
    
    /**
     * 删除
     */
    async delete(id) {
        const confirmed = await utils.confirm('确定要删除这条问句吗？', '删除确认');
        if (!confirmed) return;
        
        try {
            utils.showLoading('删除中...');
            await questionApi.delete(id);
            utils.hideLoading();
            
            utils.success('删除成功');
            this.table.ajax.reload();
            
        } catch (error) {
            utils.hideLoading();
            console.error('删除问句失败：', error);
        }
    },
    
    /**
     * 显示导入对话框
     */
    showImportDialog() {
        Swal.fire({
            title: '批量导入问句',
            html: `
                <div class="text-start">
                    <input type="file" id="importFile" class="form-control" accept=".xlsx,.xls,.csv">
                    <div class="mt-3">
                        <small class="text-muted">
                            <p>支持Excel（.xlsx, .xls）和CSV格式</p>
                            <p>Excel模板列：问句内容、问句类别、产品类别、优先级、标签、备注</p>
                            <p class="mb-0"><a href="#" onclick="questionList.downloadTemplate()">📥 下载导入模板</a></p>
                        </small>
                    </div>
                </div>
            `,
            width: 600,
            showCancelButton: true,
            confirmButtonText: '开始导入',
            cancelButtonText: '取消',
            preConfirm: () => {
                const fileInput = document.getElementById('importFile');
                const file = fileInput.files[0];
                
                if (!file) {
                    Swal.showValidationMessage('请选择文件');
                    return false;
                }
                
                return file;
            }
        }).then(async (result) => {
            if (result.isConfirmed) {
                try {
                    utils.showLoading('导入中，请稍候...');
                    
                    const res = await questionApi.batchImport(result.value);
                    
                    utils.hideLoading();
                    utils.success(`成功导入 ${res.data} 条数据`);
                    
                    // 刷新表格
                    this.table.ajax.reload();
                    
                } catch (error) {
                    utils.hideLoading();
                    console.error('导入失败：', error);
                }
            }
        });
    },
    
    /**
     * 下载导入模板
     */
    downloadTemplate() {
        // 可以指向后端提供的模板下载接口
        // 或者前端生成一个简单的模板
        utils.info('模板下载功能待实现');
    },
    
    // ==================== 产品关联配置 ====================
    
    /**
     * 配置问句的产品关联
     */
    async configProducts(questionId) {
        this.currentQuestionId = questionId;
        
        try {
            utils.showLoading('加载中...');
            
            // 获取问句信息
            const questionRes = await questionApi.getById(questionId);
            const question = questionRes.data;
            
            // 获取已关联的产品
            const productsRes = await questionApi.getRelatedProducts(questionId);
            const products = productsRes.data || [];
            
            utils.hideLoading();
            
            $('#currentQuestion').text(question.questionContent);
            this.renderProductRelationList(products);
            
            new bootstrap.Modal('#productRelationModal').show();
            
        } catch (error) {
            utils.hideLoading();
            console.error('加载产品关联失败:', error);
        }
    },
    
    /**
     * 渲染产品关联列表
     */
    renderProductRelationList(products) {
        const tbody = $('#productRelationList');
        tbody.empty();
        
        if (products.length === 0) {
            tbody.html('<tr><td colspan="4" class="text-center text-muted">暂无关联产品</td></tr>');
            return;
        }
        
        products.forEach(p => {
            const typeMap = {
                'primary': '主要产品',
                'related': '相关产品',
                'compare': '对比产品'
            };
            tbody.append(`
                <tr>
                    <td>${p.productName}</td>
                    <td>${p.brand || '-'}</td>
                    <td>${typeMap[p.relation_type] || p.relation_type}</td>
                    <td>
                        <button class="btn btn-sm btn-danger" onclick="questionList.removeProductRelation(${p.productId})">
                            移除
                        </button>
                    </td>
                </tr>
            `);
        });
    },
    
    /**
     * 刷新产品关联列表（不显示 loading 和 Modal）
     */
    async refreshProductRelationList() {
        console.log('🔄 [refreshProductRelationList] 开始刷新产品列表');
        try {
            console.log('🔄 [refreshProductRelationList] 调用API获取关联产品');
            const productsRes = await questionApi.getRelatedProducts(this.currentQuestionId);
            const products = productsRes.data || [];
            console.log('🔄 [refreshProductRelationList] 获取到产品数据:', products.length, '个');
            
            this.renderProductRelationList(products);
            console.log('🔄 [refreshProductRelationList] 产品列表渲染完成');
        } catch (error) {
            console.error('❌ [refreshProductRelationList] 刷新产品关联列表失败:', error);
        }
    },
    
    /**
     * 添加产品关联
     */
    async addProductRelation() {
        console.log('📝 [addProductRelation] 开始添加产品关联');
        const productId = $('#selectProduct').val();
        const relationType = $('#relationType').val();
        
        if (!productId) {
            utils.error('请选择产品');
            return;
        }
        
        try {
            console.log('📝 [addProductRelation] 准备显示loading');
            utils.showLoading('添加中...');
            
            console.log('📝 [addProductRelation] 调用API添加产品关联');
            await questionApi.addProductRelation(this.currentQuestionId, {
                productId: parseInt(productId),
                relationType: relationType,
                sortOrder: 0
            });
            
            console.log('📝 [addProductRelation] API调用成功，准备隐藏loading');
            utils.hideLoading();
            console.log('📝 [addProductRelation] loading已隐藏');
            
            utils.success('添加成功');
            
            // 刷新列表（不显示 loading 和 Modal）
            console.log('📝 [addProductRelation] 开始刷新产品列表');
            await this.refreshProductRelationList();
            console.log('📝 [addProductRelation] 产品列表刷新完成');
            
        } catch (error) {
            console.error('❌ [addProductRelation] 出错:', error);
            utils.hideLoading();
            console.error('添加产品关联失败:', error);
        }
    },
    
    /**
     * 移除产品关联
     */
    async removeProductRelation(productId) {
        try {
            utils.showLoading('移除中...');
            
            await questionApi.removeProductRelation(this.currentQuestionId, productId);
            
            utils.hideLoading();
            utils.success('移除成功');
            
            // 刷新列表（不显示 loading 和 Modal）
            await this.refreshProductRelationList();
            
        } catch (error) {
            utils.hideLoading();
            console.error('移除产品关联失败:', error);
        }
    },
    
    // ==================== 产品类别关联配置 ====================
    
    /**
     * 配置问句的产品类别关联
     */
    async configCategories(questionId) {
        this.currentQuestionId = questionId;
        
        try {
            utils.showLoading('加载中...');
            
            // 获取问句信息
            const questionRes = await questionApi.getById(questionId);
            const question = questionRes.data;
            
            // 获取已关联的类别
            const categoriesRes = await questionApi.getRelatedProductCategories(questionId);
            const categories = categoriesRes.data || [];
            
            utils.hideLoading();
            
            $('#currentQuestion2').text(question.questionContent);
            this.renderCategoryRelationList(categories);
            
            new bootstrap.Modal('#categoryRelationModal').show();
            
        } catch (error) {
            utils.hideLoading();
            console.error('加载类别关联失败:', error);
        }
    },
    
    /**
     * 渲染类别关联列表
     */
    renderCategoryRelationList(categories) {
        const tbody = $('#categoryRelationList');
        tbody.empty();
        
        if (categories.length === 0) {
            tbody.html('<tr><td colspan="3" class="text-center text-muted">暂无关联类别</td></tr>');
            return;
        }
        
        categories.forEach(c => {
            tbody.append(`
                <tr>
                    <td>${c}</td>
                    <td>-</td>
                    <td>
                        <button class="btn btn-sm btn-danger" onclick="questionList.removeCategoryRelation('${c}')">
                            移除
                        </button>
                    </td>
                </tr>
            `);
        });
    },
    
    /**
     * 刷新类别关联列表（不显示 loading 和 Modal）
     */
    async refreshCategoryRelationList() {
        console.log('🔄 [refreshCategoryRelationList] 开始刷新类别列表');
        try {
            console.log('🔄 [refreshCategoryRelationList] 调用API获取关联类别');
            const categoriesRes = await questionApi.getRelatedProductCategories(this.currentQuestionId);
            const categories = categoriesRes.data || [];
            console.log('🔄 [refreshCategoryRelationList] 获取到类别数据:', categories.length, '个');
            
            this.renderCategoryRelationList(categories);
            console.log('🔄 [refreshCategoryRelationList] 类别列表渲染完成');
        } catch (error) {
            console.error('❌ [refreshCategoryRelationList] 刷新类别关联列表失败:', error);
        }
    },
    
    /**
     * 添加类别关联
     */
    async addCategoryRelation() {
        console.log('📝 [addCategoryRelation] 开始添加类别关联');
        const categoryId = $('#selectCategory').val();
        const categoryName = $('#selectCategory option:selected').data('name');
        
        if (!categoryId) {
            utils.error('请选择产品类别');
            return;
        }
        
        try {
            console.log('📝 [addCategoryRelation] 准备显示loading');
            utils.showLoading('添加中...');
            
            console.log('📝 [addCategoryRelation] 调用API添加类别关联');
            await questionApi.addCategoryRelation(this.currentQuestionId, {
                categoryId: parseInt(categoryId),
                categoryName: categoryName,
                sortOrder: 0
            });
            
            console.log('📝 [addCategoryRelation] API调用成功，准备隐藏loading');
            utils.hideLoading();
            console.log('📝 [addCategoryRelation] loading已隐藏');
            
            utils.success('添加成功');
            
            // 刷新列表（不显示 loading 和 Modal）
            console.log('📝 [addCategoryRelation] 开始刷新类别列表');
            await this.refreshCategoryRelationList();
            console.log('📝 [addCategoryRelation] 类别列表刷新完成');
            
        } catch (error) {
            console.error('❌ [addCategoryRelation] 出错:', error);
            utils.hideLoading();
            console.error('添加类别关联失败:', error);
        }
    },
    
    /**
     * 移除类别关联
     */
    async removeCategoryRelation(categoryName) {
        try {
            utils.showLoading('移除中...');
            
            // 需要先通过categoryName找到categoryId
            const res = await categoryApi.getAll();
            const categories = res.data || [];
            const category = categories.find(c => c.categoryName === categoryName);
            
            if (category) {
                await questionApi.removeCategoryRelation(this.currentQuestionId, category.categoryId);
                
                utils.hideLoading();
                utils.success('移除成功');
                
                // 刷新列表（不显示 loading 和 Modal）
                await this.refreshCategoryRelationList();
            } else {
                utils.hideLoading();
                utils.error('找不到该类别');
            }
        } catch (error) {
            utils.hideLoading();
            console.error('移除类别关联失败:', error);
        }
    }
};

// 页面加载完成后初始化
$(document).ready(function() {
    console.log('=== $(document).ready 执行，开始初始化问句列表 ===');
    console.log('当前questionList对象:', questionList);
    console.log('questionList.table:', questionList.table);
    
    // 如果DataTable已存在，先销毁
    if (questionList.table) {
        console.warn('⚠️ 在ready中仍然检测到table实例，再次销毁');
        try {
            questionList.table.destroy();
        } catch (e) {
            console.log('销毁旧DataTable:', e);
        }
    }
    
    console.log('调用 questionList.init()...');
    questionList.init();
    console.log('✅ 问句列表初始化完成');
});

